/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "字符文本.h"
#include "节点/socket_utils.h"

#include "节点/节点树.h"
#include "节点/插座/字符插座.h"
#include "节点/插座/list/list数值插座.h"

#include <Context/当前默认操作数据.h>
#include <Context/数据创建销毁.h>




C_文件路径节点::C_文件路径节点(S_设备环境& ctx) : C_节点基类(DEF_文件路径节点, E_节点类型::e_节点Type_字符串) {
	m_Name = L"行字符串";
	m_Ctx = ctx;

	DEF_创建字符串插座_O(L"文本");

	m_文件路径 = f_alloc_PathProp(nullptr, L"初始值");
	m_文件路径.m_私有 = true;
}

C_文件路径节点::~C_文件路径节点() {
	f_prop_Release(m_文件路径);
}

bool C_文件路径节点::f_update() {
	auto* socket1Out = f_get输出插座(1);
	auto& str = DEF_字符串插座数据(socket1Out);

	f_prop_LineStr(str) = f_prop_Path(m_文件路径);
	return false;
}

std::string	C_文件路径节点::DEF_节点编译函数{
	m_Code = "";
	m_ReleaseCode = "";

	auto* socket1Out = f_get输出插座(1);

	auto& str = DEF_字符串插座数据(socket1Out);
	f_prop_LineStr(str) = f_prop_Path(m_文件路径);


	socket1Out->f_setCode("(*(S_Props*)" + DEF_指针到字符串(&str) + ")");
	if (m_区域父节点) {
		m_区域父节点->m_Code += m_Code;
		return "";
	}
	return m_Code;
}

void C_文件路径节点::f_读取(FILE* f) {
	C_节点基类::f_读取(f);
	
	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_节点实例属性) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		if (f_file_版本对比(文件块, S_节点数据::g_低版本号_6, S_节点数据::g_文件版本号)) {
			下一次读取数据指针 = f_prop_Load(m_文件路径, 下一次读取数据指针);
		}
	}
	free(文件块.m_data);
}

void C_文件路径节点::f_写入(FILE* f) {
	C_节点基类::f_写入(f);

	auto 文件块 = f_file_构建文件块信息(E_节点工程文件块类型::e_工程文件块_节点实例属性, S_节点数据::g_文件版本号);
	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

	f_prop_Save(m_文件路径, 块);

	f_file_保存文件块(f, 文件块, 块);
}

void C_文件路径节点::f_Copy(const C_节点基类* node) {
	C_节点基类::f_Copy(node);

	const C_文件路径节点* scr = dynamic_cast<const C_文件路径节点*>(node);
	if (scr) {
		f_prop_Path(m_文件路径) = f_prop_Path(scr->m_文件路径);
	}
}

C_节点基类* f_node_创建文件路径节点(S_设备环境& ctx, C_节点树* 子节点树) {
	return new C_行字符串变量节点(ctx);
}

C_节点基类* f_node_加载文件路径节点(S_设备环境& ctx, FILE* f) {
	C_行字符串变量节点* node = new C_行字符串变量节点(ctx);
	return node;
}

void f_node_保存文件路径节点(C_节点基类* n, FILE* f) {
	C_行字符串变量节点* node = dynamic_cast<C_行字符串变量节点*>(n);
}





C_行字符串变量节点::C_行字符串变量节点(S_设备环境& ctx) : C_节点基类(DEF_行字符串变量节点, E_节点类型::e_节点Type_字符串) {
	m_Name = L"行字符串";
	m_Ctx = ctx;

	DEF_创建字符串插座_O(L"文本");

	m_初始值 = f_alloc_LineStrProp(nullptr, L"初始值");
	m_初始值.m_私有 = true;

}

C_行字符串变量节点::~C_行字符串变量节点() {
	f_prop_Release(m_初始值);

}

bool C_行字符串变量节点::f_update() {
	auto* socket1Out = f_get输出插座(1);
	auto& str = DEF_字符串插座数据(socket1Out);

	f_prop_LineStr(str) = f_prop_LineStr(m_初始值);
	return false;
}

std::string	C_行字符串变量节点::DEF_节点编译函数{
	m_Code = "";
	m_ReleaseCode = "";

	auto* socket1Out = f_get输出插座(1);

	auto& str = DEF_字符串插座数据(socket1Out);
	f_prop_LineStr(str) = f_prop_LineStr(m_初始值);


	socket1Out->f_setCode("(*(S_Props*)" + DEF_指针到字符串(&m_初始值) + ")");
	if (m_区域父节点) {
		m_区域父节点->m_Code += m_Code;
		return "";
	}
	return m_Code;
}

void C_行字符串变量节点::f_读取(FILE* f) {
	C_节点基类::f_读取(f);

	
	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_节点实例属性) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		if (f_file_版本对比(文件块, S_节点数据::g_低版本号_6, S_节点数据::g_文件版本号)) {
			下一次读取数据指针 = f_prop_Load(m_初始值, 下一次读取数据指针);
		}
	}
	free(文件块.m_data);
	
}

void C_行字符串变量节点::f_写入(FILE* f) {
	C_节点基类::f_写入(f);

	auto 文件块 = f_file_构建文件块信息(E_节点工程文件块类型::e_工程文件块_节点实例属性, S_节点数据::g_文件版本号);
	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

	f_prop_Save(m_初始值, 块);

	f_file_保存文件块(f, 文件块, 块);
}

void C_行字符串变量节点::f_Copy(const C_节点基类* node) {
	C_节点基类::f_Copy(node);

	const C_行字符串变量节点* scr = dynamic_cast<const C_行字符串变量节点*>(node);
	if (scr) {
		f_prop_LineStr(m_初始值) = f_prop_LineStr(scr->m_初始值);
	}
}

C_节点基类* f_node_创建行字符串变量节点(S_设备环境& ctx, C_节点树* 子节点树) {
	return new C_行字符串变量节点(ctx);
}

C_节点基类* f_node_加载行字符串变量节点(S_设备环境& ctx, FILE* f) {
	C_行字符串变量节点* node = new C_行字符串变量节点(ctx);
	return node;
}

void f_node_保存行字符串变量节点(C_节点基类* n, FILE* f) {
	C_行字符串变量节点* node = dynamic_cast<C_行字符串变量节点*>(n);
}







C_数值转字符串节点::C_数值转字符串节点(S_设备环境& ctx) : C_节点基类(DEF_数值转字符串节点, E_节点类型::e_节点Type_字符串) {
	m_Name = L"行字符串";
	m_Ctx = ctx;

	DEF_创建I32插座_I(L"数值");
	DEF_创建字符串插座_O(L"文本");

	m_数值类型 = f_alloc_EnumProp(nullptr, {
		{L"整数", ""},
		{L"小数", ""},
	}, L"初始值");
	m_数值类型.m_私有 = true;

}

C_数值转字符串节点::~C_数值转字符串节点() {
	f_prop_Release(m_数值类型);

}

bool C_数值转字符串节点::f_update() {
	auto* socket1Out = f_get输出插座(1);
	auto& str = DEF_字符串插座数据(socket1Out);

	
	switch (f_prop_enum(m_数值类型)) {
		case 0: {
			f_su_切换后端插座类型(this, E_插座方向::e_插座Type_输入, 1, E_值类型::e_Type_I32);
			auto* socket1 = f_get输入插座(1);
			f_prop_整数转行字符串(str, DEF_I32插座数据(socket1));
			break;
		}
		case 1: {
			f_su_切换后端插座类型(this, E_插座方向::e_插座Type_输入, 1, E_值类型::e_Type_F32);
			auto* socket1 = f_get输入插座(1);
			f_prop_整数转行字符串(str, DEF_F32插座数据(socket1));
			break;
		}
	}
	//f_prop_LineStr(str) = f_prop_LineStr(m_数值类型);
	return false;
}

std::string	C_数值转字符串节点::DEF_节点编译函数{
	m_Code = "";
	m_ReleaseCode = "";
	auto name = f_getName();

	auto* socket1 = f_get输入插座(1);
	auto* socket1Out = f_get输出插座(1);

	//auto& str = DEF_字符串插座数据(socket1Out);

	//m_Code += DEF_S(S_Props)" " + name + " = " + DEF_S(f_prop_alloc_LineStrProp)"();\n";
	m_Code += DEF_S(S_属性*)" " + name + " = " + DEF_S(f_prop_alloc_Str)"();\n";
	m_Code += "{\n";
	m_Code += socket1->f_构建变量代码(0);

	switch (f_prop_enum(m_数值类型)) {
		case 0: {
			m_Code += DEF_S(f_prop_整数转行字符串)"(*(S_Props*)" + name + ", " + socket1->f_getCode(0) + ");\n";
			break;
		}
		case 1: {
			m_Code += DEF_S(f_prop_小数转行字符串)"(*(S_Props*)" + name + ", " + socket1->f_getCode(0) + ");\n";
			break;
		}
	}

	m_Code += m_ReleaseCode;
	m_Code += "}\n";


	socket1Out->f_setCode("(*(S_Props*)" + name + ")");
	if (m_区域父节点) {
		m_区域父节点->m_Code += m_Code;
		m_区域父节点->m_ReleaseCode += DEF_S(f_prop_free_Str)"(" + name + ");\n";
		return "";
	}
	释放 += DEF_S(f_prop_free_Str)"(" + name + ");\n";
	return m_Code;
}

void C_数值转字符串节点::f_读取(FILE* f) {
	C_节点基类::f_读取(f);


	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_节点实例属性) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		if (f_file_版本对比(文件块, S_节点数据::g_低版本号_6, S_节点数据::g_文件版本号)) {
			下一次读取数据指针 = f_prop_Load(m_数值类型, 下一次读取数据指针);
		}
	}
	free(文件块.m_data);

}

void C_数值转字符串节点::f_写入(FILE* f) {
	C_节点基类::f_写入(f);

	auto 文件块 = f_file_构建文件块信息(E_节点工程文件块类型::e_工程文件块_节点实例属性, S_节点数据::g_文件版本号);
	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

	f_prop_Save(m_数值类型, 块);

	f_file_保存文件块(f, 文件块, 块);
}

void C_数值转字符串节点::f_Copy(const C_节点基类* node) {
	C_节点基类::f_Copy(node);

	const C_数值转字符串节点* scr = dynamic_cast<const C_数值转字符串节点*>(node);
	if (scr) {
		//f_prop_LineStr(m_初始值) = f_prop_LineStr(scr->m_初始值);
	}
}

C_节点基类* f_node_创建数值转字符串节点(S_设备环境& ctx, C_节点树* 子节点树) {
	return new C_数值转字符串节点(ctx);
}

C_节点基类* f_node_加载数值转字符串节点(S_设备环境& ctx, FILE* f) {
	C_数值转字符串节点* node = new C_数值转字符串节点(ctx);
	return node;
}

void f_node_保存数值转字符串节点(C_节点基类* n, FILE* f) {
	C_数值转字符串节点* node = dynamic_cast<C_数值转字符串节点*>(n);
}






C_合并字符串节点::C_合并字符串节点(S_设备环境& ctx) : C_节点基类(DEF_合并字符串节点, E_节点类型::e_节点Type_字符串) {
	m_Name = L"合并字符串";
	m_Ctx = ctx;

	DEF_创建字符串插座_I(L"文本");
	DEF_创建字符串插座_O(L"文本");

	f_get输入插座(1)->f_set多输入();
	//m_初始值 = f_alloc_EnumProp(nullptr, {
	//	{L"整数", ""},
	//	{L"小数", ""},
	//						 }, L"初始值");
	//m_初始值.m_私有 = true;
}

C_合并字符串节点::~C_合并字符串节点() {
	//f_prop_Release(m_初始值);
}

bool C_合并字符串节点::f_update() {
	auto* socket1Out = f_get输出插座(1);
	auto& str = DEF_字符串插座数据(socket1Out);
	f_prop_LineStr(str) = L"";

	auto* socket1 = f_get输入插座(1);
	uint32 num = socket1->f_getLinkNum();
	for (uint32 i = 0; i < num; ++i) {
		f_prop_合并行字符串(str , *(S_Props*)socket1->f_getData(i));
	}
	return false;
}

std::string	C_合并字符串节点::DEF_节点编译函数{
	m_Code = "";
	m_ReleaseCode = "";
	auto name = f_getName();

	auto* socket1 = f_get输入插座(1);
	

	//m_Code += DEF_S(S_Props)" " + name + ";\n";
	m_Code += DEF_S(S_属性*)" " + name + " = " + DEF_S(f_prop_alloc_Str)"();\n";
	m_Code += "{\n";

	uint32 num = socket1->f_getLinkNum();
	for (uint32 i = 0; i < num; ++i) {
		m_Code += socket1->f_构建变量代码(i);

		m_Code += DEF_S(f_prop_合并行字符串)"(*(S_Props*)" + name + ", " + socket1->f_getCode(i) + ");\n";
	}

	m_Code += m_ReleaseCode;
	m_Code += "}\n";


	f_get输出插座(1)->f_setCode("(*(S_Props*)" + name + ")");
	if (m_区域父节点) {
		m_区域父节点->m_Code += m_Code;
		m_区域父节点->m_ReleaseCode += DEF_S(f_prop_free_Str)"(" + name + ");\n";
		return "";
	}
	释放 += DEF_S(f_prop_free_Str)"(" + name + ");\n";
	return m_Code;
}

void C_合并字符串节点::f_读取(FILE* f) {
	C_节点基类::f_读取(f);


	S_文件块 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_节点实例属性) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		if (f_file_版本对比(文件块, S_节点数据::g_低版本号_6, S_节点数据::g_文件版本号)) {
			//下一次读取数据指针 = f_prop_Load(m_初始值, 下一次读取数据指针);
		}
	}
	free(文件块.m_data);

}

void C_合并字符串节点::f_写入(FILE* f) {
	C_节点基类::f_写入(f);

	auto 文件块 = f_file_构建文件块信息(E_节点工程文件块类型::e_工程文件块_节点实例属性, S_节点数据::g_文件版本号);
	S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

	//f_prop_Save(m_初始值, 块);

	f_file_保存文件块(f, 文件块, 块);
}

void C_合并字符串节点::f_Copy(const C_节点基类* node) {
	C_节点基类::f_Copy(node);

	const C_合并字符串节点* scr = dynamic_cast<const C_合并字符串节点*>(node);
	if (scr) {
		//f_prop_LineStr(m_初始值) = f_prop_LineStr(scr->m_初始值);
	}
}

C_节点基类* f_node_创建合并字符串节点(S_设备环境& ctx, C_节点树* 子节点树) {
	return new C_合并字符串节点(ctx);
}

C_节点基类* f_node_加载合并字符串节点(S_设备环境& ctx, FILE* f) {
	C_合并字符串节点* node = new C_合并字符串节点(ctx);
	return node;
}

void f_node_保存合并字符串节点(C_节点基类* n, FILE* f) {
	C_合并字符串节点* node = dynamic_cast<C_合并字符串节点*>(n);
}

